import { extend } from 'umi-request';
import { notification, message } from 'antd';
import {
  hehLocalStorage,
  includes,
  isString,
  throttle,
  debounce,
} from '@/utils/utils';
import { useDispatch } from 'dva';
import { history } from 'umi';
import { admin_url } from '../../config/admin.config';
const codeMessage = {
  200: '服务器成功返回请求的数据。',
  201: '新建或修改数据成功。',
  202: '一个请求已经进入后台排队（异步任务）。',
  204: '删除数据成功。',
  400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
  401: '用户没有权限（令牌、用户名、密码错误）。',
  403: '用户得到授权，但是访问是被禁止的。',
  404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
  406: '请求的格式不可得。',
  410: '请求的资源被永久删除，且不会再得到的。',
  422: '当创建一个对象时，发生一个验证错误。',
  500: '服务器发生错误，请检查服务器。',
  502: '网关错误。',
  503: '服务不可用，服务器暂时过载或维护。',
  504: '网关超时。',
};
let tag = false;
const hasResponseStatusArray = [400, 401, 403, 500];
// 异常处理程序
const errorHandler = (error: { response: Response }): Response => {
  const { response } = error;
  if (response) {
    const { status, url } = response;
    // @ts-ignore
    const errorText = codeMessage[response.status] || response.statusText;
    if (
      response &&
      response.status &&
      includes(hasResponseStatusArray, response.status)
    ) {
      if (response.ok) {
        const responseJson = response.clone().json();
        responseJson.then(res => {
          if (res && res.message) {
            message.destroy();
            message.error(res.message);
          } else {
            notification.destroy();
            notification.error({
              message: `请求错误 ${status}: ${url}`,
              description: errorText,
            });
          }
        });
        console.log(`请求错误, 状态码：${status},url地址：${url},${errorText}`);
      } else {
        notification.destroy();
        notification.error({
          message: `系统异常 ${status}: ${url}`,
          description: errorText,
        });
      }
    } else if (
      response &&
      response.status &&
      response.status !== 200 &&
      !includes(hasResponseStatusArray, response.status)
    ) {
      notification.destroy();
      notification.error({
        message: `请求错误 ${status}: ${url}`,
        description: errorText,
      });
    } else if (!response) {
      notification.destroy();
      notification.error({
        description: '您的网络发生异常，无法连接服务器',
        message: '网络异常',
      });
    }
  }
  throw error;
};

// 配置request请求时的默认参数
const request = extend({
  errorHandler, // 默认错误处理
  credentials: 'include', // 默认请求是否带上cookie
});

// response拦截器, 处理response
request.interceptors.response.use(async response => {
  if (response.status === 401) {
    let baseUrl = process.env.REQUEST_SPLICING_TKEY_SSO_BASE_URL || '';
    let codeCallbackUrl = process.env.REQUEST_SPLICING_TKEY_SSO_CODE_CALLBACK;
    let pageUrl = window.location.href;
    pageUrl = encodeURIComponent(pageUrl);
    codeCallbackUrl = encodeURIComponent(codeCallbackUrl + pageUrl);
    baseUrl = baseUrl + codeCallbackUrl;
    window.location.href = baseUrl;
  }
  return response;
});

// request拦截器, 改变url 或 options.
request.interceptors.request.use((url, options) => {
  const userInfo = hehLocalStorage.getItem('userInfo');
  return {
    url: `${admin_url}${url}`,
    options: {
      ...options,
      headers: {
        'Cache-control': 'no-cache',
        Pragma: 'no-cache',
        'Content-Type': 'application/json;charset=UTF-8',
        Accept: 'application/json, text/javascript',
        Authorization: userInfo
          ? userInfo.accessToken
          : 'Basic ZmFpcm5lc3M6ZDNodGNEbz0=',
        USER_ID: userInfo ? userInfo.userId : '',
      },
    },
  };
});

const handleResponse = (
  url: string,
  data: any,
  type: string,
  options?: any,
) => {
  return new Promise<any>((resolve, reject) => {
    for (let i in data) {
      if (data && data[i] && isString(data[i])) {
        data[i] = data[i].trim();
      }
    }

    request(url, {
      method: type,
      [type === 'POST' || type === 'PUT' ? 'data' : 'params']: data,
      ...options,
    })
      .then((res: any) => {
        // @ts-ignore
        if (options && options.returnRes) {
          resolve(res);
          return;
        }
        if (res && res.success) {
          resolve(res.data);
        } else {
          message.destroy();
          message.error(res.message);
          reject(res);
        }

        if ((res && res.message === '登录过期') || res.message === '登录超时') {
          localStorage.clear();
          setTimeout(() => {
            history.push('/login/index');
          }, 300);
          tag = true;
        }
      })
      .catch(error => {
        reject(error);
      });
  });
};

const post = (url: string, data: object, options?: object) => {
  return handleResponse(url, data, 'POST', options);
};

const put = (url: string, data: object, options?: object) => {
  return handleResponse(url, data, 'PUT', options);
};

const get = (url: string, data: object, options?: object) => {
  return handleResponse(url, data, 'GET', options);
};

const del = (url: string, data: object, options?: object) => {
  return handleResponse(url, data, 'DELETE', options);
};

export { post, get, put, del };
export default request;
